// #include <iostream>
// using namespace std;
// void func1() {
//     throw string("异常");
// }
// void func2() {
//     func1();
// }
// void func3() {
//     func2();
// }
// int main() {
//     try {
//         func3();
//     } catch(const string& s) {
//         cout << "错误是：" << s << endl;
//     } catch(...) {
//         cout << "未知异常" << endl;
//     }
//     return 0;
// }


// #include <iostream>
// using namespace std;
// double Divide(int a, int b) {
//     try {
//         if(b == 0) {
//             string s("除零异常！");
//             throw s;
//         }else {
//             return ((double)a / (double)b);
//         }
//     }catch (int errid) {
//         cout << errid << endl;
//     }
//     return 0;
// }

// void Func() {
//     int len, time;
//     cin >> len >> time;
//     try {
//         cout << Divide(len, time) << endl;
//     }catch (const char* errmsg){
//         cout << errmsg << endl;
//     }

// }
// int main() {
//     while(1) {
//         try {
//             Func();
//         } catch (const string& errmsg) {
//             cout << errmsg << endl;
//             cout << "hello world" << endl;
//         }
//     }
//     return 0;
// }


// #include <iostream>
// #include <string>
// #include <cstdlib>   // For rand() and srand()
// #include <ctime>     // For time()
// #include <thread>    // For this_thread::sleep_for
// #include <chrono>    // For chrono::seconds

// using namespace std;

// // =========================================================
// // 异常基类和派生类定义
// // =========================================================

// // 一般大型项目程序才会使用异常，下面我们模拟设计一个服务的几个模块
// // 每个模块的继承都是Exception的派生类，每个模块可以添加自己的数据
// // 最后捕获时，我们捕获基类就可以  
// class Exception
// {
// public:
//     Exception(const string& errmsg, int id)
//         :_errmsg(errmsg)
//         , _id(id)
//     {}
//     // 虚函数 what() 允许通过基类指针调用派生类特定的错误信息 
//     virtual string what() const
//     {
//         return _errmsg;
//     }
//     int getid() const
//     {
//         return _id;
//     }
// protected:
//     string _errmsg;
//     int _id;
// };

// // SQL 异常，添加了 SQL 语句信息
// class SqlException : public Exception
// {
// public:
//     SqlException(const string& errmsg, int id, const string& sql)
//         :Exception(errmsg, id)
//         , _sql(sql)
//     {}
//     virtual string what() const
//     {
//         string str = "SqlException:";
//         str += _errmsg;
//         str += "->";
//         str += _sql;
//         return str;
//     }
// private:
//     const string _sql;
// };

// // 缓存异常
// class CacheException : public Exception
// {
// public:
//     CacheException(const string& errmsg, int id)
//         :Exception(errmsg, id)
//     {}
//     virtual string what() const
//     {
//         string str = "CacheException:";
//         str += _errmsg;
//         return str;
//     }
// };

// // HTTP 异常，添加了请求类型信息
// class HttpException : public Exception
// {
// public:
//     HttpException(const string& errmsg, int id, const string& type)
//         :Exception(errmsg, id)
//         , _type(type)
//     {}
//     virtual string what() const
//     {
//         string str = "HttpException:";
//         str += _type;
//         str += ":";
//         str += _errmsg;
//         return str;
//     }
// private:
//     const string _type;
// };


// // =========================================================
// // 模拟服务模块函数 (可能抛出异常)
// // =========================================================

// void SQLMgr()
// {
//     // 大约 1/7 的概率抛出 SqlException
//     if (rand() % 7 == 0)
//     {
//         throw SqlException("权限不足", 100, "select * from name = '张三'");
//     }
//     else
//     {
//         cout << "SQLMgr 调用成功" << endl;
//     }
// }

// void CacheMgr()
// {
//     // 大约 1/5 或 1/6 的概率抛出 CacheException
//     if (rand() % 5 == 0)
//     {
//         throw CacheException("权限不足", 100);
//     }
//     else if (rand() % 6 == 0)
//     {
//         throw CacheException("数据不存在", 101);
//     }
//     else
//     {
//         cout << "CacheMgr 调用成功" << endl;
//     }
    
//     // 调用下一层函数，可能会抛出 SqlException
//     SQLMgr(); 
// }

// void HttpServer()
// {
//     // 大约 1/3 或 1/4 的概率抛出 HttpException
//     if (rand() % 3 == 0)
//     {
//         throw HttpException("请求资源不存在", 100, "get");
//     }
//     else if (rand() % 4 == 0)
//     {
//         throw HttpException("权限不足", 101, "post");
//     }
//     else
//     {
//         cout << "HttpServer调用成功" << endl;
//     }
    
//     // 调用下一层函数，可能会抛出 CacheException 或 SqlException
//     CacheMgr();
// }

// // =========================================================
// // 主函数 (TRY-CATCH 统一处理)
// // =========================================================

// int main()
// {
//     srand(time(0)); // 初始化随机数种子

//     while (1)
//     {
//         std::this_thread::sleep_for(std::chrono::seconds(1)); // 每次循环暂停 1 秒

//         try 
//         {
//             HttpServer(); // 调用最上层函数
//         }
//         // 捕获基类 Exception，基类对象和派生类对象都可以被捕获 [cite: 382, 383]
//         catch (const Exception& e) 
//         {
//             // 通过虚函数 what() 打印出派生类特有的错误信息
//             cout << e.what() << endl;
//         }
//         // 捕获所有其他未知类型的异常 
//         catch (...) 
//         {
//             cout << "Unkown Exception" << endl;
//         }
//         cout << "------------------------------------------" << endl;
//     }

//     return 0;
// }

// #include <iostream>
// #include <string>
// #include <cstdlib>   // For rand() and srand()
// #include <ctime>     // For time()
// #include <thread>    // For this_thread::sleep_for
// #include <chrono>    // For chrono::seconds

// using namespace std;

// // =========================================================
// // 异常基类和派生类定义 (为了让代码能够编译，这里重新定义)
// // =========================================================

// class Exception
// {
// public:
//     Exception(const string& errmsg, int id)
//         :_errmsg(errmsg)
//         , _id(id)
//     {}
//     // 虚函数 what() 
//     virtual string what() const
//     {
//         return _errmsg;
//     }
//     int getid() const
//     {
//         return _id;
//     }
// protected:
//     string _errmsg;
//     int _id;
// };

// // HTTP 异常，添加了请求类型信息
// class HttpException : public Exception
// {
// public:
//     HttpException(const string& errmsg, int id, const string& type)
//         :Exception(errmsg, id)
//         , _type(type)
//     {}
//     // 重写 what()，增加 HTTP 请求类型信息
//     virtual string what() const
//     {
//         string str = "HttpException:";
//         str += _type;
//         str += ":";
//         str += _errmsg;
//         return str;
//     }
// private:
//     const string _type;
// };


// // =========================================================
// // 模拟消息发送函数
// // =========================================================

// /**
//  * @brief 模拟底层消息发送，可能抛出 HttpException
//  * * @param s 待发送消息
//  */
// void _SeedMsg(const string& s)
// {
//     // 1. 模拟网络不稳定错误 (错误ID: 102)，大约 50% 概率
//     if (rand() % 2 == 0)
//     {
//         throw HttpException("网络不稳定，发送失败", 102, "put");
//     }
//     // 2. 模拟好友关系错误 (错误ID: 103)，大约 1/7 概率
//     else if (rand() % 7 == 0)
//     {
//         throw HttpException("你已经不是对象的好友，发送失败", 103, "put");
//     }
//     // 3. 成功发送
//     else
//     {
//         cout << "【_SeedMsg】消息：\"" << s << "\" -> 发送成功" << endl;
//     }
// }

// /**
//  * @brief 高层消息发送逻辑，包含重试机制
//  * * @param s 待发送消息
//  */
// void SendMsg(const string& s)
// {
//     // 尝试次数：1 次初始尝试 + 3 次重试 = 共 4 次
//     const int MAX_ATTEMPTS = 4;

//     for (int i = 0; i < MAX_ATTEMPTS; i++)
//     {
//         try
//         {
//             _SeedMsg(s);
//             // 成功发送则跳出循环
//             return; 
//         }
//         catch (const Exception& e)
//         {
//             // 捕获所有自定义异常
            
//             // 检查错误 ID 是否为 102 (网络不稳定)
//             if (e.getid() == 102)
//             {
//                 // 如果是最后一次尝试 (i == MAX_ATTEMPTS - 1)，则认为网络环境不可恢复，重新抛出异常
//                 if (i == MAX_ATTEMPTS - 1)
//                 {
//                     cout << "重试" << i + 1 << "次失败，网络环境太差。" << endl;
//                     throw; // 重新抛出原始异常，交由 main 函数处理
//                 }

//                 // 否则，进行下一次重试
//                 cout << "【SendMsg】网络不稳定，开始第" << i + 2 << "次尝试..." << endl;
//                 // 可以加入短暂的等待，模拟实际延迟
//                 std::this_thread::sleep_for(std::chrono::milliseconds(200)); 
//             }
//             else
//             {
//                 // 如果不是 102 (例如：不是好友 103)，说明是非网络错误，不需要重试，直接重新抛出
//                 cout << "【SendMsg】捕获到非重试错误，直接抛出。" << endl;
//                 throw; 
//             }
//         }
//     }
// }


// // =========================================================
// // 主函数 (TRY-CATCH 统一处理)
// // =========================================================

// int main()
// {
//     srand(time(0)); // 初始化随机数种子
//     string str = "Hello C++";

//     cout << "请输入消息内容 (回车发送):" << endl;

//     while (cin >> str)
//     {
//         cout << "\n-------------------- 开始发送消息: \"" << str << "\" --------------------" << endl;
//         try
//         {
//             SendMsg(str); // 调用包含重试逻辑的函数
//         }
//         // 捕获由 SendMsg 重新抛出或未捕获的自定义异常
//         catch (const Exception& e)
//         {
//             // 打印出派生类特有的、包含上下文的错误信息
//             cout << "【MAIN CATCH】发送失败，最终原因: " << e.what() << endl;
//         }
//         // 捕获所有其他未知类型的异常 
//         catch (...)
//         {
//             cout << "【MAIN CATCH】Unkown Exception" << endl;
//         }
//         cout << "---------------------------------------------------------------------" << endl;
//     }

//     return 0;
// }

// #include <iostream>
// #include <exception>
// #include <string>

// using namespace std;

// double Divide(int a, int b)
// {
//     if (b == 0)
//     {
//         throw "Division by zero condition!";
//     }
//     return (double)a / (double)b;
// }

// void Func()
// {
//     int* array = new int[10];

//     try 
//     {
//         int len, time;
//         cout << "请输入两个整数（被除数和除数）：" << endl;
//         if (!(cin >> len >> time)) {
//              throw string("Input reading failed!");
//         }

//         cout << Divide(len, time) << endl;
//     }
//     catch (...) 
//     {
//         // 捕获异常后的首要任务：释放内存，防止内存泄漏
//         cout << "Func: 捕获异常，释放堆内存 " << array << endl;
//         delete[] array;

//         // 异常重新抛出，交给外层（main函数）处理
//         // 捕获到什么类型的异常就重新抛出什么类型
//         throw; 
//     }

//     // 正常执行流程：如果 try 块没有抛出异常，执行到这里释放内存
//     cout << "Func: 正常执行结束，释放堆内存 " << array << endl;
//     delete[] array;
// }

// int main()
// {
//     try
//     {
//         Func();
//     }
//     catch (const char* errmsg) // 捕获 Divide 抛出的 C 风格字符串异常
//     {
//         cout << "main: 捕获到 const char* 异常: " << errmsg << endl;
//     }
//     catch (const exception& e) // 捕获标准库异常
//     {
//         cout << "main: 捕获到标准库异常: " << e.what() << endl;
//     }
//     catch (...) // 捕获 Func 中重新抛出的所有其它类型异常（例如本例中新增的 string 异常）
//     {
//         cout << "main: 捕获到 Unkown Exception (非 const char* 或标准库异常)" << endl;
//     }

//     return 0;
// }


// C++98
// 这里表示我们的这个函数只会抛出bad_alloc的异常
void* operator new(std::size_t size) throw(std::bad_alloc)
// 这里表示这个函数不会抛异常
void* operator delete (std::size_t size, void* ptr) throw()

// C++11
size_type size() const noexcpet;